home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Environments / PowerLisp 2.01 / Supplemental Documentation / Documentation / Contents < prev    next >
Text File  |  1995-03-23  |  14KB  |  414 lines
  1. Common Lisp the Language, 2nd Edition
  2. -------------------------------------------------------------------------------
  3.  
  4. Contents
  5.  
  6.    *  Preface SECOND EDITION
  7.    *  Acknowledgments SECOND EDITION
  8.    *  Acknowledgments FIRST EDITION (1984)
  9.  
  10.    *  1. Introduction
  11.         o  Purpose
  12.         o  Notational Conventions
  13.              +  Decimal Numbers
  14.              +  Nil, False, and the Empty List
  15.              +  Evaluation, Expansion, and Equivalence
  16.              +  Errors
  17.              +  Descriptions of Functions and Other Entities
  18.              +  The Lisp Reader
  19.              +  Overview of Syntax
  20.  
  21.    *  2. Data Types
  22.         o  Numbers
  23.              +  Integers
  24.              +  Ratios
  25.              +  Floating-Point Numbers
  26.              +  Complex Numbers
  27.         o  Characters
  28.              +  Standard Characters
  29.              +  Line Divisions
  30.              +  Non-standard Characters
  31.              +  Character Attributes
  32.              +  String Characters
  33.         o  Symbols
  34.         o  Lists and Conses
  35.         o  Arrays
  36.              +  Vectors
  37.              +  Strings
  38.              +  Bit-Vectors
  39.         o  Hash Tables
  40.         o  Readtables
  41.         o  Packages
  42.         o  Pathnames
  43.         o  Streams
  44.         o  Random-States
  45.         o  Structures
  46.         o  Functions
  47.         o  Unreadable Data Objects
  48.         o  Overlap, Inclusion, and Disjointness of Types
  49.  
  50.    *  3. Scope and Extent
  51.  
  52.    *  4. Type Specifiers
  53.         o  Type Specifier Symbols
  54.         o  Type Specifier Lists
  55.         o  Predicating Type Specifiers
  56.         o  Type Specifiers That Combine
  57.         o  Type Specifiers That Specialize
  58.         o  Type Specifiers That Abbreviate
  59.         o  Defining New Type Specifiers
  60.         o  Type Conversion Function
  61.         o  Determining the Type of an Object
  62.         o  Type Upgrading
  63.  
  64.    *  5. Program Structure
  65.         o  Forms
  66.              +  Self-Evaluating Forms
  67.              +  Variables
  68.              +  Special Forms
  69.              +  Macros
  70.              +  Function Calls
  71.         o  Functions
  72.              +  Named Functions
  73.              +  Lambda-Expressions
  74.         o  Top-Level Forms
  75.              +  Defining Named Functions
  76.              +  Declaring Global Variables and Named Constants
  77.              +  Control of Time of Evaluation
  78.  
  79.    *  6. Predicates
  80.         o  Logical Values
  81.         o  Data Type Predicates
  82.              +  General Type Predicates
  83.              +  Specific Data Type Predicates
  84.         o  Equality Predicates
  85.         o  Logical Operators
  86.  
  87.    *  7. Control Structure
  88.         o  Constants and Variables
  89.              +  Reference
  90.              +  Assignment
  91.         o  Generalized Variables
  92.         o  Function Invocation
  93.         o  Simple Sequencing
  94.         o  Establishing New Variable Bindings
  95.         o  Conditionals
  96.         o  Blocks and Exits
  97.         o  Iteration
  98.              +  Indefinite Iteration
  99.              +  General Iteration
  100.              +  Simple Iteration Constructs
  101.              +  Mapping
  102.              +  The ``Program Feature''
  103.         o  Structure Traversal and Side Effects
  104.         o  Multiple Values
  105.              +  Constructs for Handling Multiple Values
  106.              +  Rules Governing the Passing of Multiple Values
  107.         o  Dynamic Non-Local Exits
  108.  
  109.    *  8. Macros
  110.         o  Macro Definition
  111.         o  Macro Expansion
  112.         o  Destructuring
  113.         o  Compiler Macros
  114.         o  Environments
  115.  
  116.    *  9. Declarations
  117.         o  Declaration Syntax
  118.         o  Declaration Specifiers
  119.         o  Type Declaration for Forms
  120.  
  121.    *  10. Symbols
  122.         o  The Property List
  123.         o  The Print Name
  124.         o  Creating Symbols
  125.  
  126.    *  11. Packages
  127.         o  Consistency Rules
  128.         o  Package Names
  129.         o  Translating Strings to Symbols
  130.         o  Exporting and Importing Symbols
  131.         o  Name Conflicts
  132.         o  Built-in Packages
  133.         o  Package System Functions and Variables
  134.         o  Modules
  135.         o  An Example
  136.  
  137.    * 12. Numbers
  138.         o  Precision, Contagion, and Coercion
  139.         o  Predicates on Numbers
  140.         o  Comparisons on Numbers
  141.         o  Arithmetic Operations
  142.         o  Irrational and Transcendental Functions
  143.              +  Exponential and Logarithmic Functions
  144.              +  Trigonometric and Related Functions
  145.              +  Branch Cuts, Principal Values, and Boundary Conditions in the
  146.                Complex Plane
  147.         o  Type Conversions and Component Extractions on Numbers
  148.         o  Logical Operations on Numbers
  149.         o  Byte Manipulation Functions
  150.         o  Random Numbers
  151.         o  Implementation Parameters
  152.  
  153.    *  13. Characters
  154.         o  Character Attributes
  155.         o  Predicates on Characters
  156.         o  Character Construction and Selection
  157.         o  Character Conversions
  158.         o  Character Control-Bit Functions
  159.  
  160.    *  14. Sequences
  161.         o  Simple Sequence Functions
  162.         o  Concatenating, Mapping, and Reducing Sequences
  163.         o  Modifying Sequences
  164.         o  Searching Sequences for Items
  165.         o  Sorting and Merging
  166.  
  167.    *  15. Lists
  168.         o  Conses
  169.         o  Lists
  170.         o  Alteration of List Structure
  171.         o  Substitution of Expressions
  172.         o  Using Lists as Sets
  173.         o  Association Lists
  174.  
  175.    *  16. Hash Tables
  176.         o  Hash Table Functions
  177.         o  Primitive Hash Function
  178.  
  179.    *  17. Arrays
  180.         o  Array Creation
  181.         o  Array Access
  182.         o  Array Information
  183.         o  Functions on Arrays of Bits
  184.         o  Fill Pointers
  185.         o  Changing the Dimensions of an Array
  186.  
  187.    *  18. Strings
  188.         o  String Access
  189.         o  String Comparison
  190.         o  String Construction and Manipulation
  191.  
  192.    *  19. Structures
  193.         o  Introduction to Structures
  194.         o  How to Use Defstruct
  195.         o  Using the Automatically Defined Constructor Function
  196.         o  Defstruct Slot-Options
  197.         o  Defstruct Options
  198.         o  By-Position Constructor Functions
  199.         o  Structures of Explicitly Specified Representational Type
  200.              +  Unnamed Structures
  201.              +  Named Structures
  202.              +  Other Aspects of Explicitly Specified Structures
  203.  
  204.    *  20. The Evaluator
  205.         o  Run-Time Evaluation of Forms
  206.         o  The Top-Level Loop
  207.  
  208.    *  21. Streams
  209.         o  Standard Streams
  210.         o  Creating New Streams
  211.         o  Operations on Streams
  212.  
  213.    *  22. Input/Output
  214.         o  Printed Representation of Lisp Objects
  215.              +  What the Read Function Accepts
  216.              +  Parsing of Numbers and Symbols
  217.              +  Macro Characters
  218.              +  Standard Dispatching Macro Character Syntax
  219.              +  The Readtable
  220.              +  What the Print Function Produces
  221.         o  Input Functions
  222.              +  Input from Character Streams
  223.              +  Input from Binary Streams
  224.         o  Output Functions
  225.              +  Output to Character Streams
  226.              +  Output to Binary Streams
  227.              +  Formatted Output to Character Streams
  228.         o  Querying the User
  229.  
  230.    *  23. File System Interface
  231.         o  File Names
  232.              +  Pathnames
  233.              +  Case Conventions
  234.              +  Structured Directories
  235.              +  Extended Wildcards
  236.              +  Logical Pathnames
  237.                   +  Syntax of Logical Pathname Namestrings
  238.                   +  Parsing of Logical Pathname Namestrings
  239.                   +  Using Logical Pathnames
  240.                   +  Examples of the Use of Logical Pathnames
  241.                   +  Discussion of Logical Pathnames
  242.              +  Pathname Functions
  243.         o  Opening and Closing Files
  244.         o  Renaming, Deleting, and Other File Operations
  245.         o  Loading Files
  246.         o  Accessing Directories
  247.  
  248.    *  24. Errors
  249.         o  General Error-Signaling Functions
  250.         o  Specialized Error-Signaling Forms and Macros
  251.         o  Special Forms for Exhaustive Case Analysis
  252.  
  253.    *  25. Miscellaneous Features
  254.         o  The Compiler
  255.              +  Compiler Diagnostics
  256.              +  Compiled Functions
  257.              +  Compilation Environment
  258.              +  Similarity of Constants
  259.         o  Documentation
  260.         o  Debugging Tools
  261.         o  Environment Inquiries
  262.              +  Time Functions
  263.              +  Other Environment Inquiries
  264.         o  Identity Function
  265.  
  266.    *  26. Loop
  267.         o  Introduction
  268.         o  How the Loop Facility Works
  269.         o  Parsing Loop Clauses
  270.              +  Order of Execution
  271.              +  Kinds of Loop Clauses
  272.              +  Loop Syntax
  273.         o  User Extensibility
  274.         o  Loop Constructs
  275.         o  Iteration Control
  276.         o  End-Test Control
  277.         o  Value Accumulation
  278.         o  Variable Initializations
  279.         o  Conditional Execution
  280.         o  Unconditional Execution
  281.         o  Miscellaneous Features
  282.              +  Data Types
  283.              +  Destructuring
  284.  
  285.    *  27. Pretty Printing
  286.         o  Introduction
  287.         o  Pretty Printing Control Variables
  288.         o  Dynamic Control of the Arrangement of Output
  289.         o  Format Directive Interface
  290.         o  Compiling Format Control Strings
  291.         o  Pretty Printing Dispatch Tables
  292.  
  293.    *  28. Common Lisp Object System
  294.         o  Programmer Interface Concepts
  295.              +  Error Terminology
  296.              +  Classes
  297.                   +  Defining Classes
  298.                   +  Creating Instances of Classes
  299.                   +  Slots
  300.                   +  Accessing Slots
  301.              +  Inheritance
  302.                   +  Inheritance of Methods
  303.                   +  Inheritance of Slots and Slot Options
  304.                   +  Inheritance of Class Options
  305.                   +  Examples
  306.              +  Integrating Types and Classes
  307.              +  Determining the Class Precedence List
  308.                   +  Topological Sorting
  309.                   +  Examples
  310.              +  Generic Functions and Methods
  311.                   +  Introduction to Generic Functions
  312.                   +  Introduction to Methods
  313.                   +  Agreement on Parameter Specializers and Qualifiers
  314.                   +  Congruent Lambda-Lists for All Methods of a Generic
  315.                     Function
  316.                   +  Keyword Arguments in Generic Functions and Methods
  317.              +  Method Selection and Combination
  318.                   +  Determining the Effective Method
  319.                   +  Standard Method Combination
  320.                   +  Declarative Method Combination
  321.                   +  Built-in Method Combination Types
  322.              +  Meta-objects
  323.                   +  Metaclasses
  324.                   +  Standard Metaclasses
  325.                   +  Standard Meta-objects
  326.              +  Object Creation and Initialization
  327.                   +  Initialization Arguments
  328.                   +  Declaring the Validity of Initialization Arguments
  329.                   +  Defaulting of Initialization Arguments
  330.                   +  Rules for Initialization Arguments
  331.                   +  Shared-Initialize
  332.                   +  Initialize-Instance
  333.                   +  Definitions of Make-Instance and Initialize-Instance
  334.              +  Redefining Classes
  335.                   +  Modifying the Structure of Instances
  336.                   +  Initializing Newly Added Local Slots
  337.                   +  Customizing Class Redefinition
  338.                   +  Extensions
  339.              +  Changing the Class of an Instance
  340.                   +  Modifying the Structure of an Instance
  341.                   +  Initializing Newly Added Local Slots
  342.                   +  Customizing the Change of Class of an Instance
  343.              +  Reinitializing an Instance
  344.                   +  Customizing Reinitialization
  345.         o  Functions in the Programmer Interface
  346.  
  347.    *  29. Conditions
  348.         o  Introduction
  349.         o  Changes in Terminology
  350.         o  Survey of Concepts
  351.              +  Signaling Errors
  352.              +  Trapping Errors
  353.              +  Handling Conditions
  354.              +  Object-Oriented Basis of Condition Handling
  355.              +  Restarts
  356.              +  Anonymous Restarts
  357.              +  Named Restarts
  358.              +  Restart Functions
  359.              +  Comparison of Restarts and Catch/Throw
  360.              +  Generalized Restarts
  361.              +  Interactive Condition Handling
  362.              +  Serious Conditions
  363.              +  Non-Serious Conditions
  364.              +  Condition Types
  365.              +  Signaling Conditions
  366.              +  Resignaling Conditions
  367.              +  Condition Handlers
  368.              +  Printing Conditions
  369.         o  Program Interface to the Condition System
  370.              +  Signaling Conditions
  371.              +  Assertions
  372.              +  Exhaustive Case Analysis
  373.              +  Handling Conditions
  374.              +  Defining Conditions
  375.              +  Creating Conditions
  376.              +  Establishing Restarts
  377.              +  Finding and Manipulating Restarts
  378.              +  Warnings
  379.              +  Restart Functions
  380.              +  Debugging Utilities
  381.         o  Predefined Condition Types
  382.  
  383.    *  A. Series
  384.         o  Introduction
  385.         o  Series Functions
  386.              +  Scanners
  387.              +  Mapping
  388.              +  Truncation and Other Simple Transducers
  389.              +  Conditional and Other Complex Transducers
  390.              +  Collectors
  391.              +  Alteration of Series
  392.         o  Optimization
  393.              +  Basic Restrictions
  394.              +  Constraint Cycles
  395.              +  Defining New Series Functions
  396.              +  Declarations
  397.         o  Primitives
  398.  
  399.    *  B. Generators and Gatherers
  400.         o  Introduction
  401.         o  Generators
  402.         o  Gatherers
  403.         o  Discussion
  404.  
  405.    *  C. Backquote
  406.  
  407.    *  References
  408.    *  Index
  409.  
  410.    *  About this document ...
  411.  
  412. -------------------------------------------------------------------------------
  413.  
  414.